#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#       tad.py
#version 0.1

from ficheros import *
from textos import *

class Tablero(object):
    def __init__(self):
        '''Inicializa un tablero con nueve nodos con posiciones definidas'''
        self.pos = {}
        self.pos["00"] = Nodo("00",{"e":"10", "o": None, "n": None,"s":"01"})
        self.pos["10"] = Nodo("10",{"e":"20", "o": "00", "n": None, "s":"11"})
        self.pos["20"] = Nodo("20",{"e":None, "o" : "10", "n": None,"s":"21"})
        self.pos["01"] = Nodo("01",{"e":"11", "o": None, "n": "00","s":"02"})
        self.pos["11"] = Nodo("11",{"e":"21", "o": "01", "n": "10","s":"12"})
        self.pos["21"] = Nodo("21",{"e":None, "o": "11", "n": "20","s":"22"})
        self.pos["02"] = Nodo("02",{"e":"12", "o": None, "n": "01","s":None})
        self.pos["12"] = Nodo("12",{"e":"22", "o": "02", "n": "11","s":None})
        self.pos["22"] = Nodo("22",{"e":None, "o": "12", "n": "21","s":None})
        
        self.nodo_destino = None
        self.direccion_nodo_adyacente = None
        self.nodo_aux = None
    
    def reset(self):
        self.__init__()
    
    def representar(self):
        """string"""
        #se arman las posiciones y luego se concatenan...
        estructura = r"""
            [x]→  0      →    1      →    2
             ☯--------------------------------☯
        [y] ↓|    %s     |    %s     |    %s     |
            0|  %s %s %s   |  %s %s %s   |  %s %s %s   |
             |    %s     |    %s     |    %s     |
            ↓-----------⚡----------⚡-----------
             |    %s     |    %s     |    %s     |
            1|  %s %s %s   |  %s %s %s   |  %s %s %s   |
             |    %s     |    %s     |    %s     |
            ↓-----------⚡----------⚡-----------
             |    %s     |    %s     |    %s     |
            2|  %s %s %s   |  %s %s %s   |  %s %s %s   |
             |    %s     |    %s     |    %s     |
             ☯--------------------------------☯"""

        salida =[]

        for indice, num in enumerate(["00" ,"10", "20", "01", "11", "21", "02", "12", "22"]):
            if self.pos[num].carta != None:
                salida.extend(none_a_espacios(self.pos[num].carta.norte, self.pos[num].carta.oeste, self.pos[num].carta.dueno, self.pos[num].carta.este, self.pos[num].carta.sur))

            else:
                for i in range(0,5):
                    #agrego cinco espacios
                    salida.append(" ")
        salida = arregla_listas(salida)
        print estructura % tuple(salida)

        

            
    def get_nodos_adyacentes(self, posicion): 
        '''Devuelve loas posiciones adyacentes
        Recibe: cadena, devuelve: lista'''
        return self.pos[posicion].values()      
        

    def insertar_carta(self, carta_elegida, posicion_destino, jugador1, jugador2):
        """Inserta la carta en la posicion especificada, y luego llama 
        a la comparacion"""
        self.nodo_destino = self.pos[posicion_destino] #obtengo el diccionario de adyacentes
        if (self.nodo_destino.get_carta()): # Verifica si ya hay una carta en nodoDestino
            raise ValueError ("Esa posicion ya esta ocupada")
        self.nodo_destino.set_carta(carta_elegida) #Pone la carta elegida en el destino elegido
        carta_elegida.comparar(posicion_destino, self, jugador1, jugador2)


class Pila(object):
    """Clase pila"""
    def __init__(self):
        """Constructor"""
        self.items = []
        self.largo = 0
    def __str__(self):
        """string"""
        return str(self.items)
    def __len__(self):
        """len"""
        return str(self.largo)
    def agregar(self,item):
        """Agrega un objeto a la pila"""
        self.items.append(item)
        self.largo += 1
    def liberar(self):
        """Quita elemento de la pila"""
        try:
            self.largo -= 1
            return self.items.pop()
        except:
            return None
        
    def estaVacia(self):
        """True si esta vacia, de lo contrario False"""
        return (self.items == [])


class Cola(object):
    """Clase cola"""
    def __init__(self):
        """Constructor"""
        self.items = []
        self.largo = 0
    def __str__(self):
        """string"""
        return str(self.items)
    def __len__(self):
        """len"""
        return str(self.largo)
    def agregar(self,item):
        """Agrega un objeto al principio de la cola"""
        self.items.insert(0, item)
        self.largo += 1
    def liberar(self):
        """Quita el primer elemento de la cola"""
        try:
            self.largo -= 1
            return self.items.pop()
        except:
            return None
    def estaVacia(self):
        """True si esta vacia, de lo contrario False"""
        return (self.items == [])

        
class Nodo(object):
    def __init__(self,pos, nodos_adyacentes = None, carta = None):
        self.nodos_adyacentes = nodos_adyacentes
        self.carta = carta
        self.pos = pos

    def set_carta(self, carta):
        '''Coloca la carta en el nodo'''
        self.carta = carta
    def get_carta(self):
        '''Devuelve la carta que tiene el nodo, si hay una carta en el nodo'''
        if self.carta:
            return self.carta
        else:
            return None
 
    def __str__(self):
        '''Si tiene carta devuelve la carta, sino, None'''
        if self.carta:
            return str(self.carta.__str__())

class Jugador(object):
    def __init__(self, nombre, identificador, puntaje = 5, manos_ganadas = 0, partidos_ganados = 0):
        self.nombre = nombre
        self.identificador = identificador
        self.mazo = None
        self.mano = []
        self.puntaje = puntaje
        self.manos_ganadas = manos_ganadas
        self.partidos_ganados = partidos_ganados
        
        
    def set_puntaje(self, puntaje):
        self.puntaje += puntaje
    
    def get_puntaje(self):
        """Devuelve el puntaje (como cadena)"""
        return str(self.puntaje)
        
    def reset_puntaje(self):
        self.puntaje = 5
        
    def set_mazo(self, mazo):
        """Le adjudica un mazo al jugador, y le pone su sello, identificador"""
        self.mazo = mazo
    def get_mano(self):
        """Le adjudica una mano ( 5 cartas) al jugador"""
        self.mano = self.mazo.mano
        
class Mazo(object):
    """Define un Mazo"""
    def __init__(self, ruta, jugador, cartas = None):
        self.dueno = jugador.nombre
        self.cartas =[]
        self.ruta = ruta
        self.ruta_dueno = str("/tmp/"+str(self.dueno)+".mazo")
        self.arch_salida = file
        self.mano = []
        self.identificador = jugador.identificador
        self.io = IO_control()
        
    def agregar_cartas(self, cartas_obtenidas): 
        for carta in cartas_obtenidas:
            carta.set_dueno(self.identificador)
            self.cartas.append(carta)
        self.guardar_cartas()


    


   
    def obtener_mano(self): #OK
        """Devuelve obtiene 5 cartas. Esta función es llamada 
        sólo 3 veces en todo el juego, por lo que nunca se intentará 
        obtener más cartas de las que contiene el mazo"""
        for indice in range(5):
            self.mano.append(self.cartas.pop())
        #quito las cartas de la mano
        self.quitar_cartas(self.mano)
    
    def reset_mano(self):
        """Descarta las cartas sobrantes en la mano, si las hay)"""
        self.mano = []
    


    def __str__(self): 
        self.cartas_nombre = ""
        
        for indice in range(len(self.cartas)):
            self.cartas_nombre += "* " + self.cartas[indice].nombre + " *" 
        return str("Mazo de "+ self.dueno+":\n"+ str(self.cartas_nombre))
        
    def guardar_cartas(self):
        """Guarda las cartas en un Archivo[csv]"""
        self.io.guardar_cartas(self.ruta_dueno, self.cartas)
    
    def quitar_cartas(self,mano):
        """Quita las cartas del Archivo[csv]"""
        self.io.quitar_cartas(self.ruta_dueno, mano)
    
